home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / linux / i2c.h < prev    next >
C/C++ Source or Header  |  2005-10-13  |  24KB  |  609 lines
  1. /* ------------------------------------------------------------------------- */
  2. /*                                          */
  3. /* i2c.h - definitions for the i2c-bus interface                 */
  4. /*                                          */
  5. /* ------------------------------------------------------------------------- */
  6. /*   Copyright (C) 1995-2000 Simon G. Vogl
  7.  
  8.     This program is free software; you can redistribute it and/or modify
  9.     it under the terms of the GNU General Public License as published by
  10.     the Free Software Foundation; either version 2 of the License, or
  11.     (at your option) any later version.
  12.  
  13.     This program is distributed in the hope that it will be useful,
  14.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.     GNU General Public License for more details.
  17.  
  18.     You should have received a copy of the GNU General Public License
  19.     along with this program; if not, write to the Free Software
  20.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.             */
  21. /* ------------------------------------------------------------------------- */
  22.  
  23. /* With some changes from Ky÷sti MΣlkki <kmalkki@cc.hut.fi> and
  24.    Frodo Looijaard <frodol@dds.nl> */
  25.  
  26. /* $Id: i2c.h,v 1.68 2003/01/21 08:08:16 kmalkki Exp $ */
  27.  
  28. #ifndef _LINUX_I2C_H
  29. #define _LINUX_I2C_H
  30.  
  31. #ifdef __KERNEL__
  32. #    include <linux/module.h>
  33. #    include <linux/types.h>
  34. #else
  35. #    define __KERNEL__
  36. #    include <linux/types.h>
  37. #    undef __KERNEL__
  38. #endif
  39. #include <linux/i2c-id.h>
  40. #ifdef __KERNEL__
  41. #include <linux/device.h>    /* for struct device */
  42. #include <asm/semaphore.h>
  43. #endif
  44.  
  45. /* --- General options ------------------------------------------------    */
  46.  
  47. struct i2c_msg;
  48. struct i2c_algorithm;
  49. struct i2c_adapter;
  50. struct i2c_client;
  51. struct i2c_driver;
  52. struct i2c_client_address_data;
  53. union i2c_smbus_data;
  54.  
  55. /*
  56.  * The master routines are the ones normally used to transmit data to devices
  57.  * on a bus (or read from them). Apart from two basic transfer functions to 
  58.  * transmit one message at a time, a more complex version can be used to 
  59.  * transmit an arbitrary number of messages without interruption.
  60.  */
  61. extern int i2c_master_send(struct i2c_client *,const char* ,int);
  62. extern int i2c_master_recv(struct i2c_client *,char* ,int);
  63.  
  64. /* Transfer num messages.
  65.  */
  66. extern int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg msg[],int num);
  67.  
  68. /*
  69.  * Some adapter types (i.e. PCF 8584 based ones) may support slave behaviuor. 
  70.  * This is not tested/implemented yet and will change in the future.
  71.  */
  72. extern int i2c_slave_send(struct i2c_client *,char*,int);
  73. extern int i2c_slave_recv(struct i2c_client *,char*,int);
  74.  
  75.  
  76.  
  77. /* This is the very generalized SMBus access routine. You probably do not
  78.    want to use this, though; one of the functions below may be much easier,
  79.    and probably just as fast. 
  80.    Note that we use i2c_adapter here, because you do not need a specific
  81.    smbus adapter to call this function. */
  82. extern s32 i2c_smbus_xfer (struct i2c_adapter * adapter, u16 addr, 
  83.                            unsigned short flags,
  84.                            char read_write, u8 command, int size,
  85.                            union i2c_smbus_data * data);
  86.  
  87. /* Now follow the 'nice' access routines. These also document the calling
  88.    conventions of smbus_access. */
  89.  
  90. extern s32 i2c_smbus_write_quick(struct i2c_client * client, u8 value);
  91. extern s32 i2c_smbus_read_byte(struct i2c_client * client);
  92. extern s32 i2c_smbus_write_byte(struct i2c_client * client, u8 value);
  93. extern s32 i2c_smbus_read_byte_data(struct i2c_client * client, u8 command);
  94. extern s32 i2c_smbus_write_byte_data(struct i2c_client * client,
  95.                                      u8 command, u8 value);
  96. extern s32 i2c_smbus_read_word_data(struct i2c_client * client, u8 command);
  97. extern s32 i2c_smbus_write_word_data(struct i2c_client * client,
  98.                                      u8 command, u16 value);
  99. /* Returns the number of bytes transferred */
  100. extern s32 i2c_smbus_write_block_data(struct i2c_client * client,
  101.                       u8 command, u8 length,
  102.                       u8 *values);
  103. extern s32 i2c_smbus_read_i2c_block_data(struct i2c_client * client,
  104.                      u8 command, u8 *values);
  105.  
  106. /*
  107.  * A driver is capable of handling one or more physical devices present on
  108.  * I2C adapters. This information is used to inform the driver of adapter
  109.  * events.
  110.  */
  111.  
  112. #ifdef __KERNEL__
  113. struct i2c_driver {
  114.     struct module *owner;
  115.     char name[32];
  116.     int id;
  117.     unsigned int class;
  118.     unsigned int flags;        /* div., see below        */
  119.  
  120.     /* Notifies the driver that a new bus has appeared. This routine
  121.      * can be used by the driver to test if the bus meets its conditions
  122.      * & seek for the presence of the chip(s) it supports. If found, it 
  123.      * registers the client(s) that are on the bus to the i2c admin. via
  124.      * i2c_attach_client.
  125.      */
  126.     int (*attach_adapter)(struct i2c_adapter *);
  127.     int (*detach_adapter)(struct i2c_adapter *);
  128.  
  129.     /* tells the driver that a client is about to be deleted & gives it 
  130.      * the chance to remove its private data. Also, if the client struct
  131.      * has been dynamically allocated by the driver in the function above,
  132.      * it must be freed here.
  133.      */
  134.     int (*detach_client)(struct i2c_client *);
  135.     
  136.     /* a ioctl like command that can be used to perform specific functions
  137.      * with the device.
  138.      */
  139.     int (*command)(struct i2c_client *client,unsigned int cmd, void *arg);
  140.  
  141.     struct device_driver driver;
  142.     struct list_head list;
  143. };
  144. #define to_i2c_driver(d) container_of(d, struct i2c_driver, driver)
  145.  
  146. extern struct bus_type i2c_bus_type;
  147.  
  148. #define I2C_NAME_SIZE    50
  149.  
  150. /*
  151.  * i2c_client identifies a single device (i.e. chip) that is connected to an 
  152.  * i2c bus. The behaviour is defined by the routines of the driver. This
  153.  * function is mainly used for lookup & other admin. functions.
  154.  */
  155. struct i2c_client {
  156.     int id;
  157.     unsigned int flags;        /* div., see below        */
  158.     unsigned int addr;        /* chip address - NOTE: 7bit     */
  159.                     /* addresses are stored in the    */
  160.                     /* _LOWER_ 7 bits of this char    */
  161.     /* addr: unsigned int to make lm_sensors i2c-isa adapter work
  162.       more cleanly. It does not take any more memory space, due to
  163.       alignment considerations */
  164.     struct i2c_adapter *adapter;    /* the adapter we sit on    */
  165.     struct i2c_driver *driver;    /* and our access routines    */
  166.     int usage_count;        /* How many accesses currently  */
  167.                     /* to the client        */
  168.     struct device dev;        /* the device structure        */
  169.     struct list_head list;
  170.     char name[I2C_NAME_SIZE];
  171.     struct completion released;
  172. };
  173. #define to_i2c_client(d) container_of(d, struct i2c_client, dev)
  174.  
  175. static inline void *i2c_get_clientdata (struct i2c_client *dev)
  176. {
  177.     return dev_get_drvdata (&dev->dev);
  178. }
  179.  
  180. static inline void i2c_set_clientdata (struct i2c_client *dev, void *data)
  181. {
  182.     dev_set_drvdata (&dev->dev, data);
  183. }
  184.  
  185. #define I2C_DEVNAME(str)    .name = str
  186.  
  187. static inline char *i2c_clientname(struct i2c_client *c)
  188. {
  189.     return &c->name[0];
  190. }
  191.  
  192. /*
  193.  * The following structs are for those who like to implement new bus drivers:
  194.  * i2c_algorithm is the interface to a class of hardware solutions which can
  195.  * be addressed using the same bus algorithms - i.e. bit-banging or the PCF8584
  196.  * to name two of the most common.
  197.  */
  198. struct i2c_algorithm {
  199.     char name[32];                /* textual description     */
  200.     unsigned int id;
  201.  
  202.     /* If an adapter algorithm can't to I2C-level access, set master_xfer
  203.        to NULL. If an adapter algorithm can do SMBus access, set 
  204.        smbus_xfer. If set to NULL, the SMBus protocol is simulated
  205.        using common I2C messages */
  206.     int (*master_xfer)(struct i2c_adapter *adap,struct i2c_msg msgs[], 
  207.                        int num);
  208.     int (*smbus_xfer) (struct i2c_adapter *adap, u16 addr, 
  209.                        unsigned short flags, char read_write,
  210.                        u8 command, int size, union i2c_smbus_data * data);
  211.  
  212.     /* --- these optional/future use for some adapter types.*/
  213.     int (*slave_send)(struct i2c_adapter *,char*,int);
  214.     int (*slave_recv)(struct i2c_adapter *,char*,int);
  215.  
  216.     /* --- ioctl like call to set div. parameters. */
  217.     int (*algo_control)(struct i2c_adapter *, unsigned int, unsigned long);
  218.  
  219.     /* To determine what the adapter supports */
  220.     u32 (*functionality) (struct i2c_adapter *);
  221. };
  222.  
  223. /*
  224.  * i2c_adapter is the structure used to identify a physical i2c bus along
  225.  * with the access algorithms necessary to access it.
  226.  */
  227. struct i2c_adapter {
  228.     struct module *owner;
  229.     unsigned int id;/* == is algo->id | hwdep.struct->id,         */
  230.             /* for registered values see below        */
  231.     unsigned int class;
  232.     struct i2c_algorithm *algo;/* the algorithm to access the bus    */
  233.     void *algo_data;
  234.  
  235.     /* --- administration stuff. */
  236.     int (*client_register)(struct i2c_client *);
  237.     int (*client_unregister)(struct i2c_client *);
  238.  
  239.     /* data fields that are valid for all devices    */
  240.     struct semaphore bus_lock;
  241.     struct semaphore clist_lock;
  242.  
  243.     int timeout;
  244.     int retries;
  245.     struct device dev;        /* the adapter device */
  246.     struct class_device class_dev;    /* the class device */
  247.  
  248. #ifdef CONFIG_PROC_FS 
  249.     /* No need to set this when you initialize the adapter          */
  250.     int inode;
  251. #endif /* def CONFIG_PROC_FS */
  252.  
  253.     int nr;
  254.     struct list_head clients;
  255.     struct list_head list;
  256.     char name[I2C_NAME_SIZE];
  257.     struct completion dev_released;
  258.     struct completion class_dev_released;
  259. };
  260. #define dev_to_i2c_adapter(d) container_of(d, struct i2c_adapter, dev)
  261. #define class_dev_to_i2c_adapter(d) container_of(d, struct i2c_adapter, class_dev)
  262.  
  263. static inline void *i2c_get_adapdata (struct i2c_adapter *dev)
  264. {
  265.     return dev_get_drvdata (&dev->dev);
  266. }
  267.  
  268. static inline void i2c_set_adapdata (struct i2c_adapter *dev, void *data)
  269. {
  270.     dev_set_drvdata (&dev->dev, data);
  271. }
  272. #endif
  273.  
  274. /*flags for the driver struct: */
  275. #define I2C_DF_NOTIFY    0x01        /* notify on bus (de/a)ttaches     */
  276. #if 0
  277. /* this flag is gone -- there is a (optional) driver->detach_adapter
  278.  * callback now which can be used instead */
  279. # define I2C_DF_DUMMY    0x02
  280. #endif
  281.  
  282. /*flags for the client struct: */
  283. #define I2C_CLIENT_ALLOW_USE        0x01    /* Client allows access */
  284. #define I2C_CLIENT_ALLOW_MULTIPLE_USE     0x02      /* Allow multiple access-locks */
  285.                         /* on an i2c_client */
  286. #define I2C_CLIENT_PEC  0x04            /* Use Packet Error Checking */
  287. #define I2C_CLIENT_TEN    0x10            /* we have a ten bit chip address    */
  288.                         /* Must equal I2C_M_TEN below */
  289.  
  290. /* i2c adapter classes (bitmask) */
  291. #define I2C_CLASS_HWMON        (1<<0)    /* lm_sensors, ... */
  292. #define I2C_CLASS_TV_ANALOG    (1<<1)    /* bttv + friends */
  293. #define I2C_CLASS_TV_DIGITAL    (1<<2)    /* dvb cards */
  294. #define I2C_CLASS_DDC        (1<<3)    /* i2c-matroxfb ? */
  295. #define I2C_CLASS_CAM_ANALOG    (1<<4)    /* camera with analog CCD */
  296. #define I2C_CLASS_CAM_DIGITAL    (1<<5)    /* most webcams */
  297. #define I2C_CLASS_SOUND        (1<<6)    /* sound devices */
  298. #define I2C_CLASS_ALL        (UINT_MAX) /* all of the above */
  299.  
  300. /* i2c_client_address_data is the struct for holding default client
  301.  * addresses for a driver and for the parameters supplied on the
  302.  * command line
  303.  */
  304. struct i2c_client_address_data {
  305.     unsigned short *normal_i2c;
  306.     unsigned short *normal_i2c_range;
  307.     unsigned short *probe;
  308.     unsigned short *probe_range;
  309.     unsigned short *ignore;
  310.     unsigned short *ignore_range;
  311.     unsigned short *force;
  312. };
  313.  
  314. /* Internal numbers to terminate lists */
  315. #define I2C_CLIENT_END        0xfffe
  316. #define I2C_CLIENT_ISA_END    0xfffefffe
  317.  
  318. /* The numbers to use to set I2C bus address */
  319. #define ANY_I2C_BUS        0xffff
  320. #define ANY_I2C_ISA_BUS        9191
  321.  
  322. /* The length of the option lists */
  323. #define I2C_CLIENT_MAX_OPTS 48
  324.  
  325.  
  326. /* ----- functions exported by i2c.o */
  327.  
  328. /* administration...
  329.  */
  330. extern int i2c_add_adapter(struct i2c_adapter *);
  331. extern int i2c_del_adapter(struct i2c_adapter *);
  332.  
  333. extern int i2c_add_driver(struct i2c_driver *);
  334. extern int i2c_del_driver(struct i2c_driver *);
  335.  
  336. extern int i2c_attach_client(struct i2c_client *);
  337. extern int i2c_detach_client(struct i2c_client *);
  338.  
  339. /* New function: This is to get an i2c_client-struct for controlling the 
  340.    client either by using i2c_control-function or having the 
  341.    client-module export functions that can be used with the i2c_client
  342.    -struct. */
  343. extern struct i2c_client *i2c_get_client(int driver_id, int adapter_id, 
  344.                     struct i2c_client *prev);
  345.  
  346. /* Should be used with new function
  347.    extern struct i2c_client *i2c_get_client(int,int,struct i2c_client *);
  348.    to make sure that client-struct is valid and that it is okay to access
  349.    the i2c-client. 
  350.    returns -EACCES if client doesn't allow use (default)
  351.    returns -EBUSY if client doesn't allow multiple use (default) and 
  352.    usage_count >0 */
  353. extern int i2c_use_client(struct i2c_client *);
  354. extern int i2c_release_client(struct i2c_client *);
  355.  
  356. /* call the i2c_client->command() of all attached clients with
  357.  * the given arguments */
  358. extern void i2c_clients_command(struct i2c_adapter *adap,
  359.                 unsigned int cmd, void *arg);
  360.  
  361. /* returns -EBUSY if address has been taken, 0 if not. Note that the only
  362.    other place at which this is called is within i2c_attach_client; so
  363.    you can cheat by simply not registering. Not recommended, of course! */
  364. extern int i2c_check_addr (struct i2c_adapter *adapter, int addr);
  365.  
  366. /* Detect function. It iterates over all possible addresses itself.
  367.  * It will only call found_proc if some client is connected at the
  368.  * specific address (unless a 'force' matched);
  369.  */
  370. extern int i2c_probe(struct i2c_adapter *adapter, 
  371.         struct i2c_client_address_data *address_data,
  372.         int (*found_proc) (struct i2c_adapter *, int, int));
  373.  
  374. /* An ioctl like call to set div. parameters of the adapter.
  375.  */
  376. extern int i2c_control(struct i2c_client *,unsigned int, unsigned long);
  377.  
  378. /* This call returns a unique low identifier for each registered adapter,
  379.  * or -1 if the adapter was not registered. 
  380.  */
  381. extern int i2c_adapter_id(struct i2c_adapter *adap);
  382. extern struct i2c_adapter* i2c_get_adapter(int id);
  383. extern void i2c_put_adapter(struct i2c_adapter *adap);
  384.  
  385.  
  386. /* Return the functionality mask */
  387. extern u32 i2c_get_functionality (struct i2c_adapter *adap);
  388.  
  389. /* Return 1 if adapter supports everything we need, 0 if not. */
  390. extern int i2c_check_functionality (struct i2c_adapter *adap, u32 func);
  391.  
  392. /*
  393.  * I2C Message - used for pure i2c transaction, also from /dev interface
  394.  */
  395. struct i2c_msg {
  396.     __u16 addr;    /* slave address            */
  397.      __u16 flags;        
  398. #define I2C_M_TEN    0x10    /* we have a ten bit chip address    */
  399. #define I2C_M_RD    0x01
  400. #define I2C_M_NOSTART    0x4000
  401. #define I2C_M_REV_DIR_ADDR    0x2000
  402. #define I2C_M_IGNORE_NAK    0x1000
  403. #define I2C_M_NO_RD_ACK        0x0800
  404.      __u16 len;        /* msg length                */
  405.      __u8 *buf;        /* pointer to msg data            */
  406. };
  407.  
  408. /* To determine what functionality is present */
  409.  
  410. #define I2C_FUNC_I2C            0x00000001
  411. #define I2C_FUNC_10BIT_ADDR        0x00000002
  412. #define I2C_FUNC_PROTOCOL_MANGLING    0x00000004 /* I2C_M_{REV_DIR_ADDR,NOSTART,..} */
  413. #define I2C_FUNC_SMBUS_HWPEC_CALC    0x00000008 /* SMBus 2.0 */
  414. #define I2C_FUNC_SMBUS_READ_WORD_DATA_PEC  0x00000800 /* SMBus 2.0 */ 
  415. #define I2C_FUNC_SMBUS_WRITE_WORD_DATA_PEC 0x00001000 /* SMBus 2.0 */ 
  416. #define I2C_FUNC_SMBUS_PROC_CALL_PEC    0x00002000 /* SMBus 2.0 */
  417. #define I2C_FUNC_SMBUS_BLOCK_PROC_CALL_PEC 0x00004000 /* SMBus 2.0 */
  418. #define I2C_FUNC_SMBUS_BLOCK_PROC_CALL    0x00008000 /* SMBus 2.0 */
  419. #define I2C_FUNC_SMBUS_QUICK        0x00010000 
  420. #define I2C_FUNC_SMBUS_READ_BYTE    0x00020000 
  421. #define I2C_FUNC_SMBUS_WRITE_BYTE    0x00040000 
  422. #define I2C_FUNC_SMBUS_READ_BYTE_DATA    0x00080000 
  423. #define I2C_FUNC_SMBUS_WRITE_BYTE_DATA    0x00100000 
  424. #define I2C_FUNC_SMBUS_READ_WORD_DATA    0x00200000 
  425. #define I2C_FUNC_SMBUS_WRITE_WORD_DATA    0x00400000 
  426. #define I2C_FUNC_SMBUS_PROC_CALL    0x00800000 
  427. #define I2C_FUNC_SMBUS_READ_BLOCK_DATA    0x01000000 
  428. #define I2C_FUNC_SMBUS_WRITE_BLOCK_DATA 0x02000000 
  429. #define I2C_FUNC_SMBUS_READ_I2C_BLOCK    0x04000000 /* I2C-like block xfer  */
  430. #define I2C_FUNC_SMBUS_WRITE_I2C_BLOCK    0x08000000 /* w/ 1-byte reg. addr. */
  431. #define I2C_FUNC_SMBUS_READ_I2C_BLOCK_2     0x10000000 /* I2C-like block xfer  */
  432. #define I2C_FUNC_SMBUS_WRITE_I2C_BLOCK_2 0x20000000 /* w/ 2-byte reg. addr. */
  433. #define I2C_FUNC_SMBUS_READ_BLOCK_DATA_PEC  0x40000000 /* SMBus 2.0 */
  434. #define I2C_FUNC_SMBUS_WRITE_BLOCK_DATA_PEC 0x80000000 /* SMBus 2.0 */
  435.  
  436. #define I2C_FUNC_SMBUS_BYTE I2C_FUNC_SMBUS_READ_BYTE | \
  437.                             I2C_FUNC_SMBUS_WRITE_BYTE
  438. #define I2C_FUNC_SMBUS_BYTE_DATA I2C_FUNC_SMBUS_READ_BYTE_DATA | \
  439.                                  I2C_FUNC_SMBUS_WRITE_BYTE_DATA
  440. #define I2C_FUNC_SMBUS_WORD_DATA I2C_FUNC_SMBUS_READ_WORD_DATA | \
  441.                                  I2C_FUNC_SMBUS_WRITE_WORD_DATA
  442. #define I2C_FUNC_SMBUS_BLOCK_DATA I2C_FUNC_SMBUS_READ_BLOCK_DATA | \
  443.                                   I2C_FUNC_SMBUS_WRITE_BLOCK_DATA
  444. #define I2C_FUNC_SMBUS_I2C_BLOCK I2C_FUNC_SMBUS_READ_I2C_BLOCK | \
  445.                                   I2C_FUNC_SMBUS_WRITE_I2C_BLOCK
  446. #define I2C_FUNC_SMBUS_I2C_BLOCK_2 I2C_FUNC_SMBUS_READ_I2C_BLOCK_2 | \
  447.                                    I2C_FUNC_SMBUS_WRITE_I2C_BLOCK_2
  448. #define I2C_FUNC_SMBUS_BLOCK_DATA_PEC I2C_FUNC_SMBUS_READ_BLOCK_DATA_PEC | \
  449.                                       I2C_FUNC_SMBUS_WRITE_BLOCK_DATA_PEC
  450. #define I2C_FUNC_SMBUS_WORD_DATA_PEC  I2C_FUNC_SMBUS_READ_WORD_DATA_PEC | \
  451.                                       I2C_FUNC_SMBUS_WRITE_WORD_DATA_PEC
  452.  
  453. #define I2C_FUNC_SMBUS_READ_BYTE_PEC        I2C_FUNC_SMBUS_READ_BYTE_DATA
  454. #define I2C_FUNC_SMBUS_WRITE_BYTE_PEC        I2C_FUNC_SMBUS_WRITE_BYTE_DATA
  455. #define I2C_FUNC_SMBUS_READ_BYTE_DATA_PEC    I2C_FUNC_SMBUS_READ_WORD_DATA
  456. #define I2C_FUNC_SMBUS_WRITE_BYTE_DATA_PEC    I2C_FUNC_SMBUS_WRITE_WORD_DATA
  457. #define I2C_FUNC_SMBUS_BYTE_PEC            I2C_FUNC_SMBUS_BYTE_DATA
  458. #define I2C_FUNC_SMBUS_BYTE_DATA_PEC        I2C_FUNC_SMBUS_WORD_DATA
  459.  
  460. #define I2C_FUNC_SMBUS_EMUL I2C_FUNC_SMBUS_QUICK | \
  461.                             I2C_FUNC_SMBUS_BYTE | \
  462.                             I2C_FUNC_SMBUS_BYTE_DATA | \
  463.                             I2C_FUNC_SMBUS_WORD_DATA | \
  464.                             I2C_FUNC_SMBUS_PROC_CALL | \
  465.                             I2C_FUNC_SMBUS_WRITE_BLOCK_DATA | \
  466.                             I2C_FUNC_SMBUS_WRITE_BLOCK_DATA_PEC | \
  467.                             I2C_FUNC_SMBUS_I2C_BLOCK
  468.  
  469. /* 
  470.  * Data for SMBus Messages 
  471.  */
  472. #define I2C_SMBUS_BLOCK_MAX    32    /* As specified in SMBus standard */    
  473. #define I2C_SMBUS_I2C_BLOCK_MAX    32    /* Not specified but we use same structure */
  474. union i2c_smbus_data {
  475.     __u8 byte;
  476.     __u16 word;
  477.     __u8 block[I2C_SMBUS_BLOCK_MAX + 3]; /* block[0] is used for length */
  478.                           /* one more for read length in block process call */
  479.                                                 /* and one more for PEC */
  480. };
  481.  
  482. /* smbus_access read or write markers */
  483. #define I2C_SMBUS_READ    1
  484. #define I2C_SMBUS_WRITE    0
  485.  
  486. /* SMBus transaction types (size parameter in the above functions) 
  487.    Note: these no longer correspond to the (arbitrary) PIIX4 internal codes! */
  488. #define I2C_SMBUS_QUICK            0
  489. #define I2C_SMBUS_BYTE            1
  490. #define I2C_SMBUS_BYTE_DATA        2 
  491. #define I2C_SMBUS_WORD_DATA        3
  492. #define I2C_SMBUS_PROC_CALL        4
  493. #define I2C_SMBUS_BLOCK_DATA        5
  494. #define I2C_SMBUS_I2C_BLOCK_DATA    6
  495. #define I2C_SMBUS_BLOCK_PROC_CALL   7        /* SMBus 2.0 */
  496. #define I2C_SMBUS_BLOCK_DATA_PEC    8        /* SMBus 2.0 */
  497. #define I2C_SMBUS_PROC_CALL_PEC     9        /* SMBus 2.0 */
  498. #define I2C_SMBUS_BLOCK_PROC_CALL_PEC  10    /* SMBus 2.0 */
  499. #define I2C_SMBUS_WORD_DATA_PEC       11        /* SMBus 2.0 */
  500.  
  501.  
  502. /* ----- commands for the ioctl like i2c_command call:
  503.  * note that additional calls are defined in the algorithm and hw 
  504.  *    dependent layers - these can be listed here, or see the 
  505.  *    corresponding header files.
  506.  */
  507.                 /* -> bit-adapter specific ioctls    */
  508. #define I2C_RETRIES    0x0701    /* number of times a device address      */
  509.                 /* should be polled when not            */
  510.                                 /* acknowledging             */
  511. #define I2C_TIMEOUT    0x0702    /* set timeout - call with int         */
  512.  
  513.  
  514. /* this is for i2c-dev.c    */
  515. #define I2C_SLAVE    0x0703    /* Change slave address            */
  516.                 /* Attn.: Slave address is 7 or 10 bits */
  517. #define I2C_SLAVE_FORCE    0x0706    /* Change slave address            */
  518.                 /* Attn.: Slave address is 7 or 10 bits */
  519.                 /* This changes the address, even if it */
  520.                 /* is already taken!            */
  521. #define I2C_TENBIT    0x0704    /* 0 for 7 bit addrs, != 0 for 10 bit    */
  522.  
  523. #define I2C_FUNCS    0x0705    /* Get the adapter functionality */
  524. #define I2C_RDWR    0x0707    /* Combined R/W transfer (one stop only)*/
  525. #define I2C_PEC        0x0708    /* != 0 for SMBus PEC                   */
  526. #if 0
  527. #define I2C_ACK_TEST    0x0710    /* See if a slave is at a specific address */
  528. #endif
  529.  
  530. #define I2C_SMBUS    0x0720    /* SMBus-level access */
  531.  
  532. /* ... algo-bit.c recognizes */
  533. #define I2C_UDELAY    0x0705    /* set delay in microsecs between each    */
  534.                 /* written byte (except address)    */
  535. #define I2C_MDELAY    0x0706    /* millisec delay between written bytes */
  536.  
  537. /* ----- I2C-DEV: char device interface stuff ------------------------- */
  538.  
  539. #define I2C_MAJOR    89        /* Device major number        */
  540.  
  541. /* These defines are used for probing i2c client addresses */
  542. /* Default fill of many variables */
  543. #define I2C_CLIENT_DEFAULTS {I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
  544.                           I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
  545.                           I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
  546.                           I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
  547.                           I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
  548.                           I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
  549.                           I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
  550.                           I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
  551.                           I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
  552.                           I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
  553.                           I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
  554.                           I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
  555.                           I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
  556.                           I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
  557.                           I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END, \
  558.                           I2C_CLIENT_END, I2C_CLIENT_END, I2C_CLIENT_END}
  559.  
  560. /* This is ugly. We need to evaluate I2C_CLIENT_MAX_OPTS before it is 
  561.    stringified */
  562. #define I2C_CLIENT_MODPARM_AUX1(x) "1-" #x "h"
  563. #define I2C_CLIENT_MODPARM_AUX(x) I2C_CLIENT_MODPARM_AUX1(x)
  564. #define I2C_CLIENT_MODPARM I2C_CLIENT_MODPARM_AUX(I2C_CLIENT_MAX_OPTS)
  565.  
  566. /* I2C_CLIENT_MODULE_PARM creates a module parameter, and puts it in the
  567.    module header */
  568.  
  569. #define I2C_CLIENT_MODULE_PARM(var,desc) \
  570.   static unsigned short var[I2C_CLIENT_MAX_OPTS] = I2C_CLIENT_DEFAULTS; \
  571.   static unsigned int var##_num; \
  572.   /*MODULE_PARM(var,I2C_CLIENT_MODPARM);*/ \
  573.   module_param_array(var, short, &var##_num, 0); \
  574.   MODULE_PARM_DESC(var,desc)
  575.  
  576. /* This is the one you want to use in your own modules */
  577. #define I2C_CLIENT_INSMOD \
  578.   I2C_CLIENT_MODULE_PARM(probe, \
  579.                       "List of adapter,address pairs to scan additionally"); \
  580.   I2C_CLIENT_MODULE_PARM(probe_range, \
  581.                       "List of adapter,start-addr,end-addr triples to scan " \
  582.                       "additionally"); \
  583.   I2C_CLIENT_MODULE_PARM(ignore, \
  584.                       "List of adapter,address pairs not to scan"); \
  585.   I2C_CLIENT_MODULE_PARM(ignore_range, \
  586.                       "List of adapter,start-addr,end-addr triples not to " \
  587.                       "scan"); \
  588.   I2C_CLIENT_MODULE_PARM(force, \
  589.                       "List of adapter,address pairs to boldly assume " \
  590.                       "to be present"); \
  591.     static struct i2c_client_address_data addr_data = {        \
  592.             .normal_i2c =         normal_i2c,        \
  593.             .normal_i2c_range =    normal_i2c_range,    \
  594.             .probe =        probe,            \
  595.             .probe_range =        probe_range,        \
  596.             .ignore =        ignore,            \
  597.             .ignore_range =        ignore_range,        \
  598.             .force =        force,            \
  599.         }
  600.  
  601. /* Detect whether we are on the isa bus. If this returns true, all i2c
  602.    access will fail! */
  603. #define i2c_is_isa_client(clientptr) \
  604.         ((clientptr)->adapter->algo->id == I2C_ALGO_ISA)
  605. #define i2c_is_isa_adapter(adapptr) \
  606.         ((adapptr)->algo->id == I2C_ALGO_ISA)
  607.  
  608. #endif /* _LINUX_I2C_H */
  609.